import { defineStore } from 'pinia'
import { UserWebSocket } from '../utils/websocket'
import { getUserInfo } from '../utils/auth'

export const useUserWebSocketStore = defineStore('userWebSocket', {
  state: () => ({
    ws: null, // 咨询页面连接
    identityWs: null, // 实名认证页面连接
    userId: null,
    userName: null,
    isConnected: false, // 咨询连接状态
    isIdentityConnected: false, // 实名认证连接状态
    messageHandlers: new Map(), // 存储不同页面的消息处理器
    identityMessageHandlers: new Map(), // 实名认证消息处理器
    identityVerificationCompleted: false, // 实名认证是否已完成（完成后的不再自动连接）
    serviceStatus: {
      online: false,
      name: '客服小程'
    }
  }),

  actions: {
    /**
     * 初始化 WebSocket 连接（通用方法，保留兼容性）
     */
    init() {
      this.initConsultation()
    },

    /**
     * 初始化咨询页面的 WebSocket 连接
     * 连接 key 为: user_id + service_id (1001)，由后端自动构建
     */
    initConsultation() {
      // 获取用户信息
      const userInfo = getUserInfo()
      const userId = localStorage.getItem('user_id')
      
      if (!userId) {
        console.warn('用户未登录，无法建立 WebSocket 连接')
        return
      }

      // 如果已经连接，不重复初始化
      if (this.ws && this.ws.isConnected()) {
        console.log('咨询 WebSocket 已连接，无需重复初始化')
        return
      }

      this.userId = userId
      this.userName = userInfo?.nickname || userInfo?.name || '用户'

      // 创建咨询专用的 WebSocket 连接
      // 连接 URL 为: /ws/{userId}，后端会自动使用 service_id='1001' 构建 key
      this.ws = new UserWebSocket(this.userId, this.userName)

      // 连接成功回调
      this.ws.onOpen = () => {
        this.isConnected = true
        console.log('咨询 WebSocket 连接成功，连接 key:', this.userId + '1001')
      }

      // 消息回调 - 分发给所有注册的处理器
      this.ws.onMessage = (messageData) => {
        // 分发给所有注册的处理器
        this.messageHandlers.forEach((handler) => {
          if (typeof handler === 'function') {
            handler(messageData)
          }
        })
      }

      // 错误回调
      this.ws.onError = (error) => {
        console.error('咨询 WebSocket 错误:', error)
        this.isConnected = false
      }

      // 关闭回调
      this.ws.onClose = () => {
        this.isConnected = false
        console.log('咨询 WebSocket 连接已关闭')
      }

      this.ws.connect()

      // 检查连接状态
      const checkInterval = setInterval(() => {
        if (this.ws && this.ws.isConnected()) {
          this.isConnected = true
          clearInterval(checkInterval)
        }
      }, 100)
    },

    /**
     * 断开咨询连接
     */
    disconnectConsultation() {
      console.log('断开咨询 WebSocket 连接')
      if (this.ws) {
        this.ws.disconnect()
        this.ws = null
      }
      this.isConnected = false
      // 清除消息处理器
      this.messageHandlers.clear()
    },

    /**
     * 注册消息处理器
     */
    registerMessageHandler(key, handler) {
      this.messageHandlers.set(key, handler)
    },

    /**
     * 移除消息处理器
     */
    unregisterMessageHandler(key) {
      this.messageHandlers.delete(key)
    },

    /**
     * 发送消息
     */
    sendMessage(message, extraData = {}) {
      if (!this.ws || !this.ws.isConnected()) {
        return false
      }
      return this.ws.sendMessage(message, extraData)
    },

    /**
     * 断开连接（兼容方法）
     */
    disconnect() {
      this.disconnectConsultation()
    },

    /**
     * 初始化实名认证页面的 WebSocket 连接
     * 用于接收 OCR 识别结果通知
     */
    initIdentityVerification() {
      // 如果认证已完成，不再自动连接
      if (this.identityVerificationCompleted) {
        console.log('实名认证已完成，不再自动建立连接')
        return
      }

      // 获取用户信息
      const userInfo = getUserInfo()
      const userId = localStorage.getItem('user_id')
      
      if (!userId) {
        console.warn('用户未登录，无法建立实名认证 WebSocket 连接')
        return
      }

      // 如果已经连接，不重复初始化
      if (this.identityWs && this.identityWs.isConnected()) {
        console.log('实名认证 WebSocket 已连接，无需重复初始化')
        return
      }

      // 创建实名认证专用的 WebSocket 连接
      // 连接 URL 为: /ws/{userId}
      this.identityWs = new UserWebSocket(userId, userInfo?.nickname || userInfo?.name || '用户')

      // 连接成功回调
      this.identityWs.onOpen = () => {
        this.isIdentityConnected = true
        console.log('实名认证 WebSocket 连接成功')
      }

      // 消息回调 - 分发给所有注册的处理器
      this.identityWs.onMessage = (messageData) => {
        // 分发给所有注册的实名认证处理器
        this.identityMessageHandlers.forEach((handler) => {
          if (typeof handler === 'function') {
            handler(messageData)
          }
        })
      }

      // 错误回调
      this.identityWs.onError = (error) => {
        console.error('实名认证 WebSocket 错误:', error)
        this.isIdentityConnected = false
      }

      // 关闭回调
      this.identityWs.onClose = () => {
        this.isIdentityConnected = false
        console.log('实名认证 WebSocket 连接已关闭')
      }

      this.identityWs.connect()

      // 检查连接状态
      const checkInterval = setInterval(() => {
        if (this.identityWs && this.identityWs.isConnected()) {
          this.isIdentityConnected = true
          clearInterval(checkInterval)
        }
      }, 100)
    },

    /**
     * 断开实名认证连接
     * @param {boolean} markCompleted - 是否标记为已完成（完成后不再自动连接），默认为 true
     */
    disconnectIdentityVerification(markCompleted = true) {
      console.log('断开实名认证 WebSocket 连接')
      if (this.identityWs) {
        this.identityWs.disconnect()
        this.identityWs = null
      }
      this.isIdentityConnected = false
      // 标记认证已完成，防止自动重新连接
      if (markCompleted) {
        this.identityVerificationCompleted = true
      }
      // 清除实名认证消息处理器
      this.identityMessageHandlers.clear()
    },

    /**
     * 注册实名认证消息处理器
     */
    registerIdentityMessageHandler(key, handler) {
      this.identityMessageHandlers.set(key, handler)
    },

    /**
     * 移除实名认证消息处理器
     */
    unregisterIdentityMessageHandler(key) {
      this.identityMessageHandlers.delete(key)
    },

    /**
     * 重置实名认证状态（用于需要重新认证的场景）
     */
    resetIdentityVerification() {
      this.identityVerificationCompleted = false
      console.log('实名认证状态已重置，可以重新建立连接')
    }
  }
})

